import java.util.Arrays;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 何华树
 * Date: 2024-05-14
 * Time: 20:01
 */
public class shuzu_work {

    public static int[] transform(int[] arr) {
        int [] arr1 = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr1[i] = arr[i]*2;
        }
        return arr1;
    }
    public static void main1(String[] args) {
//    实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上.
//    例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
        int[] arr = new int[]{1, 2, 3};
        int[] ret = transform(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println();
        System.out.println("==========");
        System.out.println(Arrays.toString(ret));
    }

    public static int[] bublle_sort1(int[] arr1) {
        for (int i = 0; i < arr1.length-1; i++) {
            int j = 0;
            for( j = 0;j < arr1.length-1-i;j++) {
                if(arr1[j] % 2 == 0) {
                    int tem = arr1[j];
                    arr1[j] = arr1[j+1];
                    arr1[j+1] = tem;
                }
            }
        }
        return arr1;
    }
    public static int[] sort(int[] arr) {
        int left = 0;
        int right = arr.length-1;
        while(left < right) { //循环成立条件：left 不超过 right
            while(left < right && arr[left] % 2 != 0) {
                //如果数组本来就是全都是奇数的，left会一直加加，最终数组访问越界
                //所以需要加 left < right ，同时，遇到 偶数 就停止left++，跳出循环，进行交换；
                left++;
            }
            while(left < right && arr[right] % 2 == 0) {
                //循环条件：与left的类似，遇到奇数就停下来，跳出循环，进行交换，同时避免数组访问越界
                right--;
            }
            int tem = arr[left];
            arr[left] = arr[right];
            arr[right] = tem;
        }
        return arr;
    }
    public static void main2(String[] args) {
//        调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序。
//
//如数组：[1,2,3,4,5,6]
//
//调整后可能是：[1, 5, 3, 4, 2, 6]
        //第一种方法：使用冒泡排序
        int[] arr = new int[]{1,2,3,4,5,6};
        int[] ret = bublle_sort1(arr);
        System.out.println(Arrays.toString(ret));

        System.out.println("====================");
        //第二种方法：左右两边逼近
        int[] ret1 = sort(arr);
        System.out.println(Arrays.toString(ret1));
    }

    public static int binarySearch(int[] arr,int input) {//对升序数组进行二分查找
        int left = 0;
        int right = arr.length-1;
        int mid = 0;
        while(left<=right) {
            mid = (left+right)/2;
            if(arr[mid]>input) {
                right = mid - 1;
            }else if(arr[mid]<input) {
                left = mid + 1;
            }else {
                return mid;
            }
        }
        return -1;
    }
    public static int func(int[] arr,int input) {//对降序数组进行二分查找
        int left = 0;
        int right = arr.length-1;
        int mid = 0;
        while(left <= right) {
            mid = (left+right)/2;
            if(arr[mid]>input) {
                left = mid+1;
            }else if(arr[mid]<input) {
                right = mid -1;
            }else {
                return mid;
            }
        }
        return -1;
    }
    public static void main3(String[] args) {
//    给定一个有序整型数组, 实现二分查找
        //注意：二分查找适合的是，有序的数组，对于乱序的数组，应该先排序再进行二分查找
        //下面是 升序数组的二分查找的写法
        int[] arr = new int[]{1,2,3,4,5,6,7,8};
//        int ret = Arrays.binarySearch(arr,8);// java里面，实现二分查找的数组工具方法
        Scanner s = new Scanner(System.in);
        int input = s.nextInt();
        int ret = binarySearch(arr,input);
        System.out.println(ret);
        System.out.println("===========");
        //下面是降序数组的二分查找的写法
        int[] arr1 = new  int[]{9,8,7,6,5,4,3,2,1};
        int input1 = s.nextInt();
        int ret1 = func(arr1,input1);
        System.out.println(ret1);
    }

    public static void bublle_sort(int[] arr){
        int flag = 0;
        for (int i = 0; i < arr.length-1; i++) {
            int j = 0;
            flag = 1;
            for(j = 0;j < arr.length-1-i;j++) {
                if(arr[j]>arr[j+1]) {
                    flag = 0;
                    int tem = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tem;
                }
            }
            if(flag == 1){ //进行一趟完整的冒泡排序都没有进行数值的交换，证明数组已经有序，直接返回
                return;
            }
        }
    }
    public static void main4(String[] args) {
//        给定一个整型数组, 实现冒泡排序(升序排序)
        int arr[] = new int[]{3,5,4,7,2,8,1,9,10,6};
        //Arrays.sort(arr); // java 里面的数组操作工具方法，能直接对数组进行排序，无返回值。
        bublle_sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static int[] func1(int[] arr,int target) {
        int[] arr1 = new int[2];
        for (int i = 0; i < arr.length; i++) {
            for(int j = i+1;j<arr.length;j++) {
                if(arr[i]+arr[j] == target) {
                    arr1[0] = i;
                    arr1[1] = j;
                }
            }
        }
        return arr1;
    }
    public static void main5(String[] args) {
//        给定一个整数数组 nums 和一个整数目标值 target，
//        请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
//你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
//你可以按任意顺序返回答案。
//示例 1：
//输入：nums = [2,7,11,15], target = 9
//
//输出：[0,1]
//
//解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
        int[] arr = {1,2,3,5,6,7,10,5};
        Scanner s = new Scanner(System.in);
        int target = s.nextInt();
        int[] arr1 = func1(arr,target);
        System.out.println(Arrays.toString(arr1));
    }

    public static void main6(String[] args) {
        //找单身狗： 在数组里只出现了一次的数字，其他均出现了两次或以上
        int[] arr = new int[]{1,2,1,3,2};
        int a = 0;
        for (int i = 0; i < arr.length; i++) {
            a ^=arr[i];
        }
        System.out.println(a);
    }
    public static int func2(int[] arr) {
        Arrays.sort(arr);
        return arr[arr.length/2];//这里返回的是数组元素
    }
    public static void main7(String[] args) {
//        给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
//        你可以假设数组是非空的，并且给定的数组总是存在多数元素。
//        给定的数组总是存在多数元素，好比： 10个气球，一定有 超过5个气球 是同样的颜色的。

        //思想： 给数组进行排序，中间的那个数一定是 多数元素
        int[] arr = new int[]{1,2,1,2,2,4,1,2};
        int ret = func2(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println(ret);//2
    }
    public static boolean find(int[] arr) {
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] % 2 != 0) {
                count++;
            }else {
                count = 0;
            }
            if(count == 3) {
                return true;
            }
        }
        return false;
    }
    public static void main(String[] args) {
        //判断数组里面是否有三个连续的奇数
        //思想： 定义一个计数器，遇见一个奇数就加1，遇见偶数就置 0 ，当计数器加到 3 时，返回true，否则 返回false
        int[] arr = new int[]{1,2,3,4,5,7,9,10};//有三个连续的奇数
        System.out.println(find(arr));// 结果应该是 true
    }
}
